程序员练级攻略：正式入门-[2026重制版]

// 传统方式
public class User {
    private final Long id;
    private final String name;
    private final String email;

    public User(Long id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    // getter, equals, hashCode, toString...
}

// Record方式（推荐！）
public record User(Long id, String name, String email) {}

// 使用
User user = new User(1L, "张三", "zhangsan@example.com");
System.out.println(user.name());       // 访问器
System.out.println(user.toString());   // 自动生成

List<User> users = getUserList();

// 过滤、映射、排序、收集
List<String> names = users.stream()
    .filter(u -> u.getAge() >= 18)
    .map(User::getName)
    .sorted()
    .collect(Collectors.toList());

// 分组统计
Map<String, Long> countByCity = users.stream()
    .collect(Collectors.groupingBy(
        User::getCity,
        Collectors.counting()
    ));

// 传统平台线程（受限）
ExecutorService executor = Executors.newFixedThreadPool(200);

// 虚拟线程（轻量级，可创建百万级）
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 10_000).forEach(i -> {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return i;
        });
    });
}

my-voting-app/
├── src/main/java/com/example/voting/
│   ├── VotingApplication.java          # 启动类
│   ├── config/                         # 配置类
│   │   ├── SecurityConfig.java
│   │   └── WebConfig.java
│   ├── controller/                     # 控制器层
│   │   └── VoteController.java
│   ├── service/                        # 业务逻辑层
│   │   ├── VoteService.java
│   │   └── impl/VoteServiceImpl.java
│   ├── repository/                     # 数据访问层
│   │   ├── VoteRepository.java
│   │   └── UserRepository.java
│   ├── entity/                         # 实体类
│   │   ├── Vote.java
│   │   └── User.java
│   ├── dto/                            # 数据传输对象
│   │   ├── VoteRequest.java
│   │   └── VoteResponse.java
│   ├── exception/                      # 异常处理
│   │   └── GlobalExceptionHandler.java
│   └── util/                           # 工具类
├── src/main/resources/
│   ├── application.yml                 # 配置文件
│   └── data.sql                        # 初始化数据
├── src/test/java/                      # 测试代码
└── pom.xml                             # Maven配置

@RestController
@RequestMapping("/api/v1/votes")
@RequiredArgsConstructor
@Tag(name = "投票管理", description = "投票相关接口")
public class VoteController {

    private final VoteService voteService;

    @PostMapping
    @Operation(summary = "创建投票")
    public ResponseEntity<VoteResponse> createVote(
            @Valid @RequestBody VoteRequest request,
            @AuthenticationPrincipal UserDetails user) {
        VoteResponse response = voteService.createVote(request, user.getUsername());
        return ResponseEntity.status(HttpStatus.CREATED).body(response);
    }

    @GetMapping("/{voteId}")
    @Operation(summary = "获取投票详情")
    public ResponseEntity<VoteResponse> getVote(@PathVariable Long voteId) {
        return ResponseEntity.ok(voteService.getVoteById(voteId));
    }

    @PostMapping("/{voteId}/cast")
    @Operation(summary = "参与投票")
    public ResponseEntity<Void> castVote(
            @PathVariable Long voteId,
            @RequestParam List<Long> optionIds,
            HttpServletRequest request) {
        // 防刷票：检查IP限制
        String clientIp = getClientIp(request);
        voteService.castVote(voteId, optionIds, clientIp);
        return ResponseEntity.ok().build();
    }

    @GetMapping("/{voteId}/results")
    @Operation(summary = "获取投票结果")
    public ResponseEntity<VoteResultResponse> getResults(@PathVariable Long voteId) {
        return ResponseEntity.ok(voteService.getVoteResults(voteId));
    }
}

@Entity
@Table(name = "votes", indexes = {
    @Index(name = "idx_vote_status", columnList = "status"),
    @Index(name = "idx_vote_creator", columnList = "creator_id")
})
@NamedQuery(
    name = "Vote.findActive",
    query = "SELECT v FROM Vote v WHERE v.status = 'ACTIVE' AND v.endTime > CURRENT_TIMESTAMP"
)
public class Vote {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, length = 200)
    private String title;

    @Column(columnDefinition = "TEXT")
    private String description;

    @Enumerated(EnumType.STRING)
    @Column(nullable = false)
    private VoteType type; // SINGLE, MULTIPLE

    @Column(nullable = false)
    private LocalDateTime startTime;

    @Column(nullable = false)
    private LocalDateTime endTime;

    @Enumerated(EnumType.STRING)
    @Column(nullable = false)
    private VoteStatus status; // DRAFT, ACTIVE, CLOSED

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "creator_id", nullable = false)
    private User creator;

    @OneToMany(mappedBy = "vote", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<VoteOption> options = new ArrayList<>();

    // 审计字段
    @CreatedDate
    private LocalDateTime createdAt;

    @LastModifiedDate
    private LocalDateTime updatedAt;

    // getters, setters...
}

public interface VoteRepository extends JpaRepository<Vote, Long>, JpaSpecificationExecutor<Vote> {

    // 方法名派生查询
    List<Vote> findByStatusAndEndTimeAfter(VoteStatus status, LocalDateTime now);

    List<Vote> findByCreatorIdOrderByCreatedAtDesc(Long creatorId);

    // 自定义Query
    @Query("SELECT v FROM Vote v WHERE v.status = :status ORDER BY v.createdAt DESC")
    Page<Vote> findActiveVotes(@Param("status") VoteStatus status, Pageable pageable);

    // 原生SQL（复杂查询时使用）
    @Query(value = """
        SELECT v.*, COUNT(vo.id) as option_count
        FROM votes v
        LEFT JOIN vote_options vo ON v.id = vo.vote_id
        WHERE v.creator_id = :creatorId
        GROUP BY v.id
        """, nativeQuery = true)
    List<Object[]> findVoteStatistics(@Param("creatorId") Long creatorId);
}

// VoteCard.tsx - 投票卡片组件
import { useState } from 'react';
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
import axios from 'axios';

interface Vote {
  id: number;
  title: string;
  type: 'SINGLE' | 'MULTIPLE';
  options: VoteOption[];
  endTime: string;
  userVoted: boolean;
}

interface VoteOption {
  id: number;
  text: string;
  voteCount: number;
  percentage: number;
}

export function VoteCard({ voteId }: { voteId: number }) {
  const [selectedOptions, setSelectedOptions] = useState<number[]>([]);
  const queryClient = useQueryClient();

  // 获取投票详情
  const { data: vote, isLoading } = useQuery({
    queryKey: ['vote', voteId],
    queryFn: () => axios.get(`/api/v1/votes/${voteId}`).then(r => r.data),
  });

  // 提交投票
  const castVoteMutation = useMutation({
    mutationFn: () =>
      axios.post(`/api/v1/votes/${voteId}/cast`, null, {
        params: { optionIds: selectedOptions },
      }),
    onSuccess: () => {
      // 刷新数据
      queryClient.invalidateQueries({ queryKey: ['vote', voteId] });
    },
  });

  if (isLoading) return <div className="animate-pulse">加载中...</div>;
  if (!vote) return null;

  // 切换选中项：单选直接替换，多选做增删切换
  const toggleOption = (optionId: number) => {
    if (vote.type === 'SINGLE') {
      setSelectedOptions([optionId]);
    } else {
      setSelectedOptions(prev =>
        prev.includes(optionId) ? prev.filter(id => id !== optionId) : [...prev, optionId]
      );
    }
  };

  const isExpired = new Date(vote.endTime) < new Date();

  return (
    <div className="bg-white rounded-xl shadow-lg p-6 max-w-2xl mx-auto">
      <h2 className="text-xl font-bold mb-2">{vote.title}</h2>
      <p className="text-gray-500 text-sm mb-4">
        截止时间: {new Date(vote.endTime).toLocaleString('zh-CN')}
        {isExpired && <span className="text-red-500 ml-2">已结束</span>}
      </p>

      <div className="space-y-3">
        {vote.options.map(option => (
          <button
            key={option.id}
            onClick={() => toggleOption(option.id)}
            disabled={isExpired || vote.userVoted}
            className={`w-full p-4 rounded-lg border-2 transition-all ${
              selectedOptions.includes(option.id)
                ? 'border-blue-500 bg-blue-50'
                : 'border-gray-200 hover:border-blue-300'
            }`}
          >
            <div className="flex justify-between items-center">
              <span>{option.text}</span>
              <span className="font-semibold">{option.percentage.toFixed(1)}%</span>
            </div>
            {/* 进度条 */}
            <div className="mt-2 h-2 bg-gray-100 rounded-full overflow-hidden">
              <div
                className="h-full bg-blue-500 rounded-full transition-all"
                style={{ width: `${option.percentage}%` }}
              />
            </div>
            <div className="text-xs text-gray-500 mt-1">
              {option.voteCount} 票
            </div>
          </button>
        ))}
      </div>

      {!isExpired && !vote.userVoted && (
        <button
          onClick={() => castVoteMutation.mutate()}
          disabled={selectedOptions.length === 0 || castVoteMutation.isPending}
          className="mt-6 w-full py-3 bg-blue-600 text-white rounded-lg font-semibold
                     hover:bg-blue-700 disabled:bg-gray-300 disabled:cursor-not-allowed"
        >
          {castVoteMutation.isPending ? '提交中...' : '提交投票'}
        </button>
      )}
    </div>
  );
}

# 日常开发流程
git checkout -b feature/new-feature    # 创建功能分支
git add .                              # 暂存更改
git commit -m "feat: add user login"   # 提交（遵循Conventional Commits）
git push origin feature/new-feature   # 推送到远程

# 合并到主分支
git checkout main
git pull origin main
git merge feature/new-feature         # 合并
git push origin main                   # 推送

# 解决冲突后
git add .
git commit --no-edit                   # 使用默认合并信息

# 撤销操作
git reset HEAD~1                       # 撤销上次commit（保留更改）
git checkout -- file.txt               # 撤销文件修改
git revert <commit-hash>               # 安全撤销（生成新commit）

# API设计最佳实践

# 1. URL设计（名词复数，层级清晰）
GET    /api/v1/users              # 获取用户列表
GET    /api/v1/users/{id}         # 获取单个用户
POST   /api/v1/users              # 创建用户
PUT    /api/v1/users/{id}         # 更新用户（全量）
PATCH  /api/v1/users/{id}         # 更新用户（部分）
DELETE /api/v1/users/{id}         # 删除用户

# 2. 使用正确的状态码
200 OK                  # 成功GET/PUT/PATCH
201 Created             # 成功POST（创建资源）
204 No Content          # 成功DELETE
400 Bad Request         # 请求参数错误
401 Unauthorized        # 未认证
403 Forbidden           # 无权限
404 Not Found           # 资源不存在
409 Conflict            # 资源冲突
422 Unprocessable Entity  # 语义错误（验证失败）
500 Internal Server Error # 服务器内部错误

# 3. 请求/响应格式
# Request Header
Content-Type: application/json
Authorization: Bearer <token>
Accept-Language: zh-CN

# Response Body
{
  "code": 200,
  "message": "success",
  "data": { ... },
  "timestamp": "2026-01-15T10:30:00Z"
}

// 使用BCrypt（推荐）
@Service
public class UserService {

    private final PasswordEncoder passwordEncoder;

    public User register(RegisterRequest request) {
        // 加密密码
        String encodedPassword = passwordEncoder.encode(request.getPassword());
        User user = new User(request.getUsername(), encodedPassword, request.getEmail());
        return userRepository.save(user);
    }

    public boolean authenticate(String rawPassword, String encodedPassword) {
        return passwordEncoder.matches(rawPassword, encodedPassword);
    }
}

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.disable())
            .sessionManagement(session ->
                session.sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            )
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/v1/auth/**").permitAll()
                .requestMatchers("/api/v1/public/**").permitAll()
                .requestMatchers(HttpMethod.GET, "/api/v1/votes/**").permitAll()
                .anyRequest().authenticated()
            )
            .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);

        return http.build();
    }
}

@ExtendWith(MockitoExtension.class)
class VoteServiceTest {

    @Mock
    private VoteRepository voteRepository;

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private VoteServiceImpl voteService;

    @Test
    @DisplayName("应该成功创建投票")
    void shouldCreateVoteSuccessfully() {
        // Given
        User creator = new User(1L, "testuser", "test@example.com");
        VoteRequest request = new VoteRequest("测试投票", VoteType.SINGLE,
            List.of(new OptionRequest("选项A"), new OptionRequest("选项B")));

        when(userRepository.findByUsername("testuser")).thenReturn(Optional.of(creator));
        when(voteRepository.save(any())).thenAnswer(invocation -> invocation.getArgument(0));

        // When
        VoteResponse response = voteService.createVote(request, "testuser");

        // Then
        assertThat(response.getTitle()).isEqualTo("测试投票");
        assertThat(response.getStatus()).isEqualTo(VoteStatus.DRAFT);
        verify(voteRepository).save(any(Vote.class));
    }

    @Test
    @DisplayName("重复投票应该抛出异常")
    void shouldThrowExceptionWhenDuplicateVote() {
        // Given - 设置已投票的场景
        when(voteRepository.hasUserVoted(anyLong(), anyString())).thenReturn(true);

        // When & Then
        assertThatThrownBy(() ->
            voteService.castVote(1L, List.of(1L), "127.0.0.1")
        ).isInstanceOf(DuplicateVoteException.class)
         .hasMessage("您已经参与过该投票");

        verify(voteRepository, never()).save(any());
    }
}

@SpringBootTest
@Testcontainers
class VoteRepositoryIntegrationTest {

    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16-alpine")
        .withDatabaseName("testdb")
        .withUsername("test")
        .withPassword("test");

    @DynamicPropertySource
    static void configureProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", postgres::getJdbcUrl);
        registry.add("spring.datasource.username", postgres::getUsername);
        registry.add("spring.datasource.password", postgres::getPassword);
    }

    @Autowired
    private VoteRepository voteRepository;

    @Test
    void shouldSaveAndRetrieveVote() {
        Vote vote = new Vote();
        vote.setTitle("集成测试投票");
        vote.setStatus(VoteStatus.ACTIVE);

        Vote saved = voteRepository.save(vote);

        assertThat(saved.getId()).isNotNull();
        assertThat(voteRepository.findById(saved.getId())).isPresent();
    }
}

voting-system/
├── backend/                          # 后端项目
│   ├── src/main/java/com/example/voting/
│   │   ├── config/                   # 配置类
│   │   ├── controller/               # REST控制器
│   │   ├── service/                  # 业务逻辑
│   │   ├── repository/               # 数据访问
│   │   ├── entity/                   # 实体
│   │   ├── dto/                      # 数据传输对象
│   │   ├── security/                 # 安全相关
│   │   ├── exception/                # 异常处理
│   │   └── util/                     # 工具类
│   ├── src/test/java/                # 测试
│   └── pom.xml
├── frontend/                          # 前端项目
│   ├── src/
│   │   ├── components/               # 通用组件
│   │   ├── pages/                    # 页面组件
│   │   ├── hooks/                    # 自定义Hooks
│   │   ├── services/                 # API服务
│   │   ├── store/                    # 状态管理
│   │   ├── types/                    # TypeScript类型
│   │   └── utils/                    # 工具函数
│   ├── package.json
│   └── vite.config.ts
├── docker-compose.yml                # Docker编排
├── README.md
└── .github/workflows/                # CI/CD